home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Interfaces / PInterfaces / Lists.p < prev    next >
Encoding:
Text File  |  1996-05-05  |  9.1 KB  |  317 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Lists.p
  3.  
  4.      Contains:    List Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.1.3
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT Lists;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __LISTS__}
  30. {$SETC __LISTS__ := 1}
  31.  
  32. {$I+}
  33. {$SETC ListsIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __TYPES__}
  38. {$I Types.p}
  39. {$ENDC}
  40. {    ConditionalMacros.p                                            }
  41.  
  42. {$IFC UNDEFINED __CONTROLS__}
  43. {$I Controls.p}
  44. {$ENDC}
  45. {    Quickdraw.p                                                    }
  46. {        MixedMode.p                                                }
  47. {        QuickdrawText.p                                            }
  48. {    Menus.p                                                        }
  49. {        Memory.p                                                }
  50.  
  51. {$IFC UNDEFINED __MEMORY__}
  52. {$I Memory.p}
  53. {$ENDC}
  54.  
  55. {$PUSH}
  56. {$ALIGN MAC68K}
  57. {$LibExport+}
  58.  
  59. CONST
  60.     lDoVAutoscroll                = 2;
  61.     lDoHAutoscroll                = 1;
  62.     lOnlyOne                    = -128;
  63.     lExtendDrag                    = 64;
  64.     lNoDisjoint                    = 32;
  65.     lNoExtend                    = 16;
  66.     lNoRect                        = 8;
  67.     lUseSense                    = 4;
  68.     lNoNilHilite                = 2;
  69.  
  70.     lDoVAutoscrollBit            = 1;
  71.     lDoHAutoscrollBit            = 0;
  72.     lOnlyOneBit                    = 7;
  73.     lExtendDragBit                = 6;
  74.     lNoDisjointBit                = 5;
  75.     lNoExtendBit                = 4;
  76.     lNoRectBit                    = 3;
  77.     lUseSenseBit                = 2;
  78.     lNoNilHiliteBit                = 1;
  79.  
  80.     lInitMsg                    = 0;
  81.     lDrawMsg                    = 1;
  82.     lHiliteMsg                    = 2;
  83.     lCloseMsg                    = 3;
  84.  
  85. TYPE
  86.     ListPtr = ^ListRec;
  87.     ListHandle = ^ListPtr;
  88.  
  89.     ListRef = ListHandle;
  90.  
  91.     Cell = Point;
  92.  
  93.     ListBounds = Rect;
  94.  
  95.     DataArray = PACKED ARRAY [0..32000] OF CHAR;
  96.  
  97.     DataPtr = ^DataArray;
  98.     DataHandle = ^DataPtr;
  99.  
  100.     ListSearchProcPtr = ProcPtr;  { FUNCTION ListSearch(aPtr: Ptr; bPtr: Ptr; aLen: INTEGER; bLen: INTEGER): INTEGER; }
  101.     {
  102.         ListClickLoopProcPtr uses register based parameters on the 68k and cannot
  103.         be written in or called from a high-level language without the help of
  104.         mixed mode or assembly glue.
  105.  
  106.         In:
  107.          =>                 .?
  108.         Out:
  109.          <= return value    D0.B
  110.     }
  111.     ListClickLoopProcPtr = Register68kProcPtr;  { register FUNCTION ListClickLoop: BOOLEAN; }
  112.     ListSearchUPP = UniversalProcPtr;
  113.     ListClickLoopUPP = UniversalProcPtr;
  114.  
  115.     ListRec = RECORD
  116.         rView:                    Rect;
  117.         port:                    GrafPtr;
  118.         indent:                    Point;
  119.         cellSize:                Point;
  120.         visible:                ListBounds;
  121.         vScroll:                ControlRef;
  122.         hScroll:                ControlRef;
  123.         selFlags:                SInt8;
  124.         lActive:                BOOLEAN;
  125.         lReserved:                SInt8;
  126.         listFlags:                SInt8;
  127.         clikTime:                LONGINT;
  128.         clikLoc:                Point;
  129.         mouseLoc:                Point;
  130.         lClickLoop:                ListClickLoopUPP;
  131.         lastClick:                Cell;
  132.         refCon:                    LONGINT;
  133.         listDefProc:            Handle;
  134.         userHandle:                Handle;
  135.         dataBounds:                ListBounds;
  136.         cells:                    DataHandle;
  137.         maxIndex:                INTEGER;
  138.         cellArray:                ARRAY [0..0] OF INTEGER;
  139.     END;
  140.  
  141.     ListDefProcPtr = ProcPtr;  { PROCEDURE ListDef(lMessage: INTEGER; lSelect: BOOLEAN; VAR lRect: Rect; lCell: Cell; lDataOffset: INTEGER; lDataLen: INTEGER; lHandle: ListRef); }
  142.     ListCellDrawProcPtr = ProcPtr;  { PROCEDURE ListCellDraw(lMessage: INTEGER; lSelect: BOOLEAN; VAR lRect: Rect; lCell: Cell; dataPtr: UNIV Ptr; lDataLen: INTEGER; lHandle: ListRef); }
  143.     ListDefUPP = UniversalProcPtr;
  144.     ListCellDrawUPP = UniversalProcPtr;
  145.  
  146. CONST
  147.     uppListSearchProcInfo = $00002BE0; { FUNCTION (4 byte param, 4 byte param, 2 byte param, 2 byte param): 2 byte result; }
  148.     uppListClickLoopProcInfo = $00000012; { Register FUNCTION : 1 byte in D0; }
  149.     uppListDefProcInfo = $000EBD80; { PROCEDURE (2 byte param, 1 byte param, 4 byte param, 4 byte param, 2 byte param, 2 byte param, 4 byte param); }
  150.     uppListCellDrawProcInfo = $000EFD80; { PROCEDURE (2 byte param, 1 byte param, 4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param); }
  151.  
  152. FUNCTION NewListSearchProc(userRoutine: ListSearchProcPtr): ListSearchUPP;
  153.     {$IFC NOT GENERATINGCFM }
  154.     INLINE $2E9F;
  155.     {$ENDC}
  156.  
  157. FUNCTION NewListClickLoopProc(userRoutine: ListClickLoopProcPtr): ListClickLoopUPP;
  158.     {$IFC NOT GENERATINGCFM }
  159.     INLINE $2E9F;
  160.     {$ENDC}
  161.  
  162. FUNCTION NewListDefProc(userRoutine: ListDefProcPtr): ListDefUPP;
  163.     {$IFC NOT GENERATINGCFM }
  164.     INLINE $2E9F;
  165.     {$ENDC}
  166.  
  167. FUNCTION NewListCellDrawProc(userRoutine: ListCellDrawProcPtr): ListCellDrawUPP;
  168.     {$IFC NOT GENERATINGCFM }
  169.     INLINE $2E9F;
  170.     {$ENDC}
  171.  
  172. FUNCTION CallListSearchProc(aPtr: Ptr; bPtr: Ptr; aLen: INTEGER; bLen: INTEGER; userRoutine: ListSearchUPP): INTEGER;
  173.     {$IFC NOT GENERATINGCFM}
  174.     INLINE $205F, $4E90;
  175.     {$ENDC}
  176.  
  177. FUNCTION CallListClickLoopProc(userRoutine: ListClickLoopUPP): BOOLEAN;
  178.     {$IFC NOT GENERATINGCFM}
  179.     {To be implemented:  Glue to move parameters into registers.}
  180.     {$ENDC}
  181.  
  182. PROCEDURE CallListDefProc(lMessage: INTEGER; lSelect: BOOLEAN; VAR lRect: Rect; lCell: Cell; lDataOffset: INTEGER; lDataLen: INTEGER; lHandle: ListRef; userRoutine: ListDefUPP);
  183.     {$IFC NOT GENERATINGCFM}
  184.     INLINE $205F, $4E90;
  185.     {$ENDC}
  186.  
  187. PROCEDURE CallListCellDrawProc(lMessage: INTEGER; lSelect: BOOLEAN; VAR lRect: Rect; lCell: Cell; dataPtr: UNIV Ptr; lDataLen: INTEGER; lHandle: ListRef; userRoutine: ListCellDrawUPP);
  188.     {$IFC NOT GENERATINGCFM}
  189.     INLINE $205F, $4E90;
  190.     {$ENDC}
  191.  
  192. FUNCTION LNew({CONST}VAR rView: Rect; {CONST}VAR dataBounds: ListBounds; cSize: Point; theProc: INTEGER; theWindow: WindowRef; drawIt: BOOLEAN; hasGrow: BOOLEAN; scrollHoriz: BOOLEAN; scrollVert: BOOLEAN): ListRef;
  193.     {$IFC NOT GENERATINGCFM}
  194.     INLINE $3F3C, $0044, $A9E7;
  195.     {$ENDC}
  196. PROCEDURE LDispose(lHandle: ListRef);
  197.     {$IFC NOT GENERATINGCFM}
  198.     INLINE $3F3C, $0028, $A9E7;
  199.     {$ENDC}
  200. FUNCTION LAddColumn(count: INTEGER; colNum: INTEGER; lHandle: ListRef): INTEGER;
  201.     {$IFC NOT GENERATINGCFM}
  202.     INLINE $3F3C, $0004, $A9E7;
  203.     {$ENDC}
  204. FUNCTION LAddRow(count: INTEGER; rowNum: INTEGER; lHandle: ListRef): INTEGER;
  205.     {$IFC NOT GENERATINGCFM}
  206.     INLINE $3F3C, $0008, $A9E7;
  207.     {$ENDC}
  208. PROCEDURE LDelColumn(count: INTEGER; colNum: INTEGER; lHandle: ListRef);
  209.     {$IFC NOT GENERATINGCFM}
  210.     INLINE $3F3C, $0020, $A9E7;
  211.     {$ENDC}
  212. PROCEDURE LDelRow(count: INTEGER; rowNum: INTEGER; lHandle: ListRef);
  213.     {$IFC NOT GENERATINGCFM}
  214.     INLINE $3F3C, $0024, $A9E7;
  215.     {$ENDC}
  216. FUNCTION LGetSelect(next: BOOLEAN; VAR theCell: Cell; lHandle: ListRef): BOOLEAN;
  217.     {$IFC NOT GENERATINGCFM}
  218.     INLINE $3F3C, $003C, $A9E7;
  219.     {$ENDC}
  220. FUNCTION LLastClick(lHandle: ListRef): Cell;
  221.     {$IFC NOT GENERATINGCFM}
  222.     INLINE $3F3C, $0040, $A9E7;
  223.     {$ENDC}
  224. FUNCTION LNextCell(hNext: BOOLEAN; vNext: BOOLEAN; VAR theCell: Cell; lHandle: ListRef): BOOLEAN;
  225.     {$IFC NOT GENERATINGCFM}
  226.     INLINE $3F3C, $0048, $A9E7;
  227.     {$ENDC}
  228. FUNCTION LSearch(dataPtr: UNIV Ptr; dataLen: INTEGER; searchProc: ListSearchUPP; VAR theCell: Cell; lHandle: ListRef): BOOLEAN;
  229.     {$IFC NOT GENERATINGCFM}
  230.     INLINE $3F3C, $0054, $A9E7;
  231.     {$ENDC}
  232. PROCEDURE LSize(listWidth: INTEGER; listHeight: INTEGER; lHandle: ListRef);
  233.     {$IFC NOT GENERATINGCFM}
  234.     INLINE $3F3C, $0060, $A9E7;
  235.     {$ENDC}
  236. PROCEDURE LSetDrawingMode(drawIt: BOOLEAN; lHandle: ListRef);
  237.     {$IFC NOT GENERATINGCFM}
  238.     INLINE $3F3C, $002C, $A9E7;
  239.     {$ENDC}
  240. PROCEDURE LScroll(dCols: INTEGER; dRows: INTEGER; lHandle: ListRef);
  241.     {$IFC NOT GENERATINGCFM}
  242.     INLINE $3F3C, $0050, $A9E7;
  243.     {$ENDC}
  244. PROCEDURE LAutoScroll(lHandle: ListRef);
  245.     {$IFC NOT GENERATINGCFM}
  246.     INLINE $3F3C, $0010, $A9E7;
  247.     {$ENDC}
  248. PROCEDURE LUpdate(theRgn: RgnHandle; lHandle: ListRef);
  249.     {$IFC NOT GENERATINGCFM}
  250.     INLINE $3F3C, $0064, $A9E7;
  251.     {$ENDC}
  252. PROCEDURE LActivate(act: BOOLEAN; lHandle: ListRef);
  253.     {$IFC NOT GENERATINGCFM}
  254.     INLINE $4267, $A9E7;
  255.     {$ENDC}
  256. PROCEDURE LCellSize(cSize: Point; lHandle: ListRef);
  257.     {$IFC NOT GENERATINGCFM}
  258.     INLINE $3F3C, $0014, $A9E7;
  259.     {$ENDC}
  260. FUNCTION LClick(pt: Point; modifiers: INTEGER; lHandle: ListRef): BOOLEAN;
  261.     {$IFC NOT GENERATINGCFM}
  262.     INLINE $3F3C, $0018, $A9E7;
  263.     {$ENDC}
  264. PROCEDURE LAddToCell(dataPtr: UNIV Ptr; dataLen: INTEGER; theCell: Cell; lHandle: ListRef);
  265.     {$IFC NOT GENERATINGCFM}
  266.     INLINE $3F3C, $000C, $A9E7;
  267.     {$ENDC}
  268. PROCEDURE LClrCell(theCell: Cell; lHandle: ListRef);
  269.     {$IFC NOT GENERATINGCFM}
  270.     INLINE $3F3C, $001C, $A9E7;
  271.     {$ENDC}
  272. PROCEDURE LGetCell(dataPtr: UNIV Ptr; VAR dataLen: INTEGER; theCell: Cell; lHandle: ListRef);
  273.     {$IFC NOT GENERATINGCFM}
  274.     INLINE $3F3C, $0038, $A9E7;
  275.     {$ENDC}
  276. PROCEDURE LRect(VAR cellRect: Rect; theCell: Cell; lHandle: ListRef);
  277.     {$IFC NOT GENERATINGCFM}
  278.     INLINE $3F3C, $004C, $A9E7;
  279.     {$ENDC}
  280. PROCEDURE LSetCell(dataPtr: UNIV Ptr; dataLen: INTEGER; theCell: Cell; lHandle: ListRef);
  281.     {$IFC NOT GENERATINGCFM}
  282.     INLINE $3F3C, $0058, $A9E7;
  283.     {$ENDC}
  284. PROCEDURE LSetSelect(setIt: BOOLEAN; theCell: Cell; lHandle: ListRef);
  285.     {$IFC NOT GENERATINGCFM}
  286.     INLINE $3F3C, $005C, $A9E7;
  287.     {$ENDC}
  288. PROCEDURE LDraw(theCell: Cell; lHandle: ListRef);
  289.     {$IFC NOT GENERATINGCFM}
  290.     INLINE $3F3C, $0030, $A9E7;
  291.     {$ENDC}
  292. PROCEDURE LGetCellDataLocation(VAR offset: INTEGER; VAR len: INTEGER; theCell: Cell; lHandle: ListRef);
  293.     {$IFC NOT GENERATINGCFM}
  294.     INLINE $3F3C, $0034, $A9E7;
  295.     {$ENDC}
  296. {$IFC OLDROUTINENAMES }
  297. PROCEDURE LDoDraw(drawIt: BOOLEAN; lHandle: ListRef);
  298.     {$IFC NOT GENERATINGCFM}
  299.     INLINE $3F3C, $002C, $A9E7;
  300.     {$ENDC}
  301. PROCEDURE LFind(VAR offset: INTEGER; VAR len: INTEGER; theCell: Cell; lHandle: ListRef);
  302.     {$IFC NOT GENERATINGCFM}
  303.     INLINE $3F3C, $0034, $A9E7;
  304.     {$ENDC}
  305. {$ENDC}
  306.  
  307. {$ALIGN RESET}
  308. {$POP}
  309.  
  310. {$SETC UsingIncludes := ListsIncludes}
  311.  
  312. {$ENDC} {__LISTS__}
  313.  
  314. {$IFC NOT UsingIncludes}
  315.  END.
  316. {$ENDC}
  317.